# Formato: un caso de prueba por línea. A su vez, los datos de las
# líneas están contenidos en columnas, separadas entre si por uno
# o más caracteres de espacios (SP),
#
# nombre SP status SP input SP reference SP output SP command ...
#
# Los comentarios se indican con el caracter numeral (#). Líneas
# en blanco son ignoradas. Para más información, consultar con la
# documentación provista en el archivo runtest.cc.
#
# $Date: 2007/04/21 12:35:10 $


####################################################
####################################################
####                                            ####
#### Pruebas de FixedSizeRegisterSequentialFile ####
####                                            ####
####################################################
####################################################

# Caso 0: Lectura y escritura de un archivo registros de tamaño fijo.
fsrsf00	0	fsrsf00.in	fsrsf00.ref	fsrsf00.t	./fsrsf_ts fsrsf00.in fsrsf00.t



####################################################
####################################################
####                                            ####
####       Pruebas de DictionaryTermsFile       ####
####                                            ####
####################################################
####################################################

# Caso 0: Escritura de archivo de Registros de Diccionario.
#	Opciones:
#		ReadBuffer  = 1
#		WriteBuffer = 1
#		Incluye Random = true
dtf00	0	dtf00.in	dtf00.ref	dtf00.t		./dtf_ts 1 1 -l -tobin dtf00.in dtf00.t

# Caso 1: Lectura de archivo de Registros de Diccionario
#	Opciones:
#		ReadBuffer  = 1
#		WriteBuffer = 1
#		Incluye Random = true
dtf01	0	dtf01.in	dtf01.ref	dtf01.t		./dtf_ts 1 1 -l -totxt dtf01.in dtf01.t

# Caso 2: Escritura de archivo de Registros de Diccionario
#	Opciones:
#		ReadBuffer  = 1
#		WriteBuffer = 1
#		Incluye Random = false
dtf02	0	dtf02.in	dtf02.ref	dtf02.t		./dtf_ts 1 1 -s -tobin dtf02.in dtf02.t

# Caso 3: Lectura de archivo de Registros de Diccionario
#	Opciones:
#		ReadBuffer  = 1
#		WriteBuffer = 1
#		Incluye Random = false
dtf03	0	dtf03.in	dtf03.ref	dtf03.t		./dtf_ts 1 1 -s -totxt dtf03.in dtf03.t

# Caso 4: Escritura de archivo de Registros de Diccionario
#	Opciones:
#		ReadBuffer  = 10
#		WriteBuffer = 10
#		Incluye Random = true
dtf04	0	dtf04.in	dtf04.ref	dtf04.t		./dtf_ts 10 10 -l -tobin dtf04.in dtf04.t

# Caso 5: Escritura de archivo de Registros de Diccionario
#	Opciones:
#		ReadBuffer  = 10
#		WriteBuffer = 10
#		Incluye Random = true
dtf05	0	dtf05.in	dtf05.ref	dtf05.t		./dtf_ts 10 10 -l -totxt dtf05.in dtf05.t

# Caso 6: Escritura de archivo de Registros de Diccionario
#	Opciones:
#		ReadBuffer  = 15
#		WriteBuffer = 15
#		Incluye Random = false
dtf06	0	dtf06.in	dtf06.ref	dtf06.t		./dtf_ts 15 15 -s -tobin dtf06.in dtf06.t

# Caso 7: Escritura de archivo de Registros de Diccionario
#	Opciones:
#		ReadBuffer  = 15
#		WriteBuffer = 15
#		Incluye Random = false
dtf07	0	dtf07.in	dtf07.ref	dtf07.t		./dtf_ts 15 15 -s -totxt dtf07.in dtf07.t



####################################################
####################################################
####                                            ####
####       Pruebas de FixedSizeBlockFile        ####
####                                            ####
####################################################
####################################################

# Caso 0: Escritura de archivo de Bloques
fsbf00   0   fsbf00.in    fsbf00.ref   fsbf00.t     ./fsbf_ts 1 fsbf00.t

# Caso 1: Lectura de archivo de Bloques
fsbf01   0   fsbf01.in    fsbf01.ref   fsbf01.t     ./fsbf_ts 2 fsbf01.t fsbf01.in



####################################################
####################################################
####                                            ####
####    Pruebas de VariableStringSerializer     ####
####                                            ####
####################################################
####################################################

# Caso 0: Serialización
vss00   0   vss00.in    vss00.ref   vss00.t     ./vss_ts -s vss00.in vss00.t

# Caso 1: Deserialización
vss01   0   vss01.in    vss01.ref   vss01.t     ./vss_ts -d vss01.in vss01.t



####################################################
####################################################
####                                            ####
####         Pruebas de ListSerializer          ####
####                                            ####
####################################################
####################################################

# Caso 0: Serialización de archivo de texto pequeño
ls00   0   ls00.in    ls00.ref   ls00.t     ./ls_ts -s ls00.in ls00.t

# Caso 1: Deserialización de archivo de texto pequeño
ls01   0   ls01.in    ls01.ref   ls01.t     ./ls_ts -d ls01.in ls01.t

# Caso 2: Serialización de archivo de texto con lineas vacias (listas vacias)
ls02   0   ls02.in    ls02.ref   ls02.t     ./ls_ts -s ls02.in ls02.t

# Caso 3: Deserialización de archivo de texto con lineas vacias (listas vacias)
ls03   0   ls03.in    ls03.ref   ls03.t     ./ls_ts -d ls03.in ls03.t

# Caso 4: Serialización de archivo de texto grande
ls04   0   ls04.in    ls04.ref   ls04.t     ./ls_ts -s ls04.in ls04.t

# Caso 5: Deserialización de archivo de texto grande
ls05   0   ls05.in    ls05.ref   ls05.t     ./ls_ts -d ls05.in ls05.t



####################################################
####################################################
####                                            ####
####      Pruebas de HashRecordSerializer       ####
####                                            ####
####################################################
####################################################

# Caso 0: Serialización de archivo de texto pequeño
hrs00   0   hrs00.in    hrs00.ref   hrs00.t     ./hrs_ts -s hrs00.in hrs00.t

# Caso 1: Deserialización de archivo de texto pequeño
hrs01   0   hrs01.in    hrs01.ref   hrs01.t     ./hrs_ts -d hrs01.in hrs01.t



####################################################
####################################################
####                                            ####
####      Pruebas de HashBucketSerializer       ####
####                                            ####
####################################################
####################################################

# Caso 0: Serialización
hbs00   0   hbs00.in    hbs00.ref   hbs00.t     ./hbs_ts -s hbs00.in hbs00.t

# Caso 1: Deserialización
hbs01   0   hbs01.in    hbs01.ref   hbs01.t     ./hbs_ts -d hbs01.in hbs01.t



####################################################
####################################################
####                                            ####
####           Pruebas de HashBucket            ####
####                                            ####
####################################################
####################################################

# Caso 0: Todo el testSuite de HashBucket
# Se usa un fake file vacio como archivo de entrada/salida/referencia
# 	porque lo único que nos importa es el return status del tests

hb00   0   hb00.fake    hb00.fake   hb00.fake     ./hb_ts



####################################################
####################################################
####                                            ####
####            Pruebas de HashFile             ####
####                                            ####
####################################################
####################################################

# Caso 0: Convierto un archivo de texto (formato hashfile) a uno binario
hf00   0   hf00.in    hf00.ref   hf00.t     ./text2hash hf00.in hf00.t -b 1024 

# Caso 1: Convierto un archivo binario a uno de texto (formato hashfile)
hf01   0   hf01.in    hf01.ref   hf01.t     ./hash2text hf01.in hf01.t



####################################################
####################################################
####                                            ####
####       Pruebas del FrontCodingEncoder       ####
####                                            ####
####################################################
####################################################

# Caso 0: Codificación de un archivo pequeño
fc00   0   fc00.in    fc00.ref   fc00.t     ./fc_ts -e fc00.in fc00.t

# Caso 1: Decodificación de un archivo pequeño
fc01   0   fc01.in    fc01.ref   fc01.t     ./fc_ts -d fc01.in fc01.t



############################################################
############################################################
####                                                    ####
#### Pruebas del Serializador de Registros de Nodo Hoja ####
####                                                    ####
############################################################
############################################################

# Caso 0: Serialización de registros
lrs00   0   lrs00.in    lrs00.ref   lrs00.t     ./lrs_ts -s lrs00.in lrs00.t

# Caso 1: Deserialización de registros
lrs01   0   lrs01.in    lrs01.ref   lrs01.t     ./lrs_ts -d lrs01.in lrs01.t



####################################################
####################################################
####                                            ####
####   Pruebas del Serializador de Nodos Hoja   ####
####                                            ####
####################################################
####################################################

# Caso 0: Serialización de nodos
lns00   0   lns00.in    lns00.ref   lns00.t     ./lns_ts -s lns00.in lns00.t

# Caso 1: Deserialización de nodos
lns01   0   lns01.in    lns01.ref   lns01.t     ./lns_ts -d lns01.in lns01.t



###############################################################
###############################################################
####                                                       ####
#### Pruebas del Serializador de Registros de Nodo Interno ####
####                                                       ####
###############################################################
###############################################################

# Caso 0: Serialización de registros
irs00   0   irs00.in    irs00.ref   irs00.t     ./irs_ts -s irs00.in irs00.t

# Caso 1: Deserialización de registros
irs01   0   irs01.in    irs01.ref   irs01.t     ./irs_ts -d irs01.in irs01.t



####################################################
####################################################
####                                            ####
#### Pruebas del Serializador de Nodos Internos ####
####                                            ####
####################################################
####################################################

# Caso 0: Serialización de nodos
ins00   0   ins00.in    ins00.ref   ins00.t     ./ins_ts -s ins00.in ins00.t

# Caso 1: Deserialización de nodos
ins01   0   ins01.in    ins01.ref   ins01.t     ./ins_ts -d ins01.in ins01.t



####################################################
####################################################
####                                            ####
####       Pruebas de la Lógica del Tree        ####
####                                            ####
####################################################
####################################################

# Caso 0: Todas las pruebas del arbol
#tree00   0   tree00.in    tree00.ref   tree00.t     ./tree_ts > tree00.t

